/**
 * usePreferences Composable
 * 
 * 用于管理用户偏好设置的 Vue 组合式函数
 * 
 * @author yangzhixin
 * @module composables/usePreferences
 */

import { ref, watch, type Ref } from 'vue';
import type { CornerstoneFacade } from 'js-3d-model';

/**
 * 主题类型
 */
export enum Theme {
  Light = 'light',
  Dark = 'dark',
  Auto = 'auto',
}

/**
 * 语言类型
 */
export enum Language {
  Chinese = 'zh-CN',
  English = 'en-US',
}

/**
 * 用户偏好设置接口
 */
export interface UserPreferences {
  /** 主题 */
  theme: Theme;
  /** 语言 */
  language: Language;
  /** 默认窗宽窗位 */
  defaultWindowLevel?: {
    windowWidth: number;
    windowCenter: number;
  };
  /** 是否启用GPU渲染 */
  useGPURendering: boolean;
  /** 是否启用性能监控 */
  enablePerformanceMonitor: boolean;
  /** 最大缓存大小(MB) */
  maxCacheSize: number;
  /** 是否自动保存标注 */
  autoSaveAnnotations: boolean;
  /** 自动保存间隔(秒) */
  autoSaveInterval: number;
  /** 是否显示网格 */
  showGrid: boolean;
  /** 是否显示标尺 */
  showRuler: boolean;
  /** 是否显示方向标记 */
  showOrientationMarker: boolean;
  /** 图像插值方式 */
  interpolationType: 'LINEAR' | 'NEAREST';
  /** 自定义设置 */
  custom?: Record<string, any>;
}

/**
 * usePreferences 返回类型
 */
export interface UsePreferencesReturn {
  /** 用户偏好设置 */
  preferences: Ref<UserPreferences>;
  /** 是否正在加载 */
  isLoading: Ref<boolean>;
  /** 错误信息 */
  error: Ref<string | null>;
  /** 加载偏好设置 */
  loadPreferences: () => Promise<void>;
  /** 保存偏好设置 */
  savePreferences: () => Promise<void>;
  /** 更新偏好设置 */
  updatePreference: <K extends keyof UserPreferences>(
    key: K,
    value: UserPreferences[K]
  ) => Promise<void>;
  /** 批量更新偏好设置 */
  updatePreferences: (updates: Partial<UserPreferences>) => Promise<void>;
  /** 重置为默认设置 */
  resetToDefaults: () => Promise<void>;
  /** 导出设置 */
  exportPreferences: () => Promise<string>;
  /** 导入设置 */
  importPreferences: (data: string) => Promise<void>;
}

/**
 * 默认偏好设置
 */
const defaultPreferences: UserPreferences = {
  theme: Theme.Auto,
  language: Language.Chinese,
  useGPURendering: true,
  enablePerformanceMonitor: false,
  maxCacheSize: 512,
  autoSaveAnnotations: true,
  autoSaveInterval: 60,
  showGrid: false,
  showRuler: true,
  showOrientationMarker: true,
  interpolationType: 'LINEAR',
};

/**
 * usePreferences - 用户配置管理
 * 
 * 提供响应式的用户偏好设置管理，支持持久化存储
 * 
 * @param facade - CornerstoneFacade 实例
 * @param autoLoad - 是否自动加载设置，默认为 true
 * @param autoSave - 是否自动保存设置，默认为 true
 * @returns 偏好设置管理方法和状态
 * 
 * @example
 * ```vue
 * <script setup>
 * import { usePreferences } from '@/composables/usePreferences';
 * import { useCornerstone3D } from '@/composables/useCornerstone3D';
 * 
 * const { facade } = useCornerstone3D();
 * const { 
 *   preferences, 
 *   updatePreference 
 * } = usePreferences(facade);
 * 
 * // 更新主题
 * await updatePreference('theme', Theme.Dark);
 * </script>
 * ```
 */
export function usePreferences(
  facade: Ref<CornerstoneFacade | null>,
  autoLoad: boolean = true,
  autoSave: boolean = true
): UsePreferencesReturn {
  // 响应式状态
  const preferences = ref<UserPreferences>({ ...defaultPreferences });
  const isLoading = ref(false);
  const error = ref<string | null>(null);

  /**
   * 加载偏好设置
   */
  const loadPreferences = async (): Promise<void> => {
    if (!facade.value) {
      console.warn('[usePreferences] Cornerstone3D 未初始化，使用默认设置');
      return;
    }

    try {
      isLoading.value = true;
      error.value = null;

      console.log('[usePreferences] 加载偏好设置...');

      const saved = await facade.value.getUserPreferences();

      if (saved) {
        preferences.value = {
          ...defaultPreferences,
          ...saved,
        };
        console.log('[usePreferences] 偏好设置加载成功');
      } else {
        console.log('[usePreferences] 未找到保存的设置，使用默认值');
      }
    } catch (err: any) {
      console.error('[usePreferences] 加载偏好设置失败:', err);
      error.value = err.message || '加载偏好设置失败';
      // 使用默认设置
      preferences.value = { ...defaultPreferences };
    } finally {
      isLoading.value = false;
    }
  };

  /**
   * 保存偏好设置
   */
  const savePreferences = async (): Promise<void> => {
    if (!facade.value) {
      throw new Error('Cornerstone3D 未初始化');
    }

    try {
      console.log('[usePreferences] 保存偏好设置...');

      await facade.value.saveUserPreferences({
        preferences: preferences.value,
      });

      console.log('[usePreferences] 偏好设置保存成功');
    } catch (err: any) {
      console.error('[usePreferences] 保存偏好设置失败:', err);
      error.value = err.message || '保存偏好设置失败';
      throw err;
    }
  };

  /**
   * 更新单个偏好设置
   * 
   * @param key - 设置键名
   * @param value - 设置值
   */
  const updatePreference = async <K extends keyof UserPreferences>(
    key: K,
    value: UserPreferences[K]
  ): Promise<void> => {
    try {
      console.log(`[usePreferences] 更新设置: ${String(key)} =`, value);

      preferences.value[key] = value;

      if (autoSave) {
        await savePreferences();
      }

      console.log('[usePreferences] 设置更新成功');
    } catch (err: any) {
      console.error('[usePreferences] 更新设置失败:', err);
      error.value = err.message || '更新设置失败';
      throw err;
    }
  };

  /**
   * 批量更新偏好设置
   * 
   * @param updates - 更新的设置
   */
  const updatePreferences = async (
    updates: Partial<UserPreferences>
  ): Promise<void> => {
    try {
      console.log('[usePreferences] 批量更新设置:', updates);

      preferences.value = {
        ...preferences.value,
        ...updates,
      };

      if (autoSave) {
        await savePreferences();
      }

      console.log('[usePreferences] 设置批量更新成功');
    } catch (err: any) {
      console.error('[usePreferences] 批量更新设置失败:', err);
      error.value = err.message || '批量更新设置失败';
      throw err;
    }
  };

  /**
   * 重置为默认设置
   */
  const resetToDefaults = async (): Promise<void> => {
    try {
      console.log('[usePreferences] 重置为默认设置...');

      preferences.value = { ...defaultPreferences };

      if (autoSave) {
        await savePreferences();
      }

      console.log('[usePreferences] 设置已重置');
    } catch (err: any) {
      console.error('[usePreferences] 重置设置失败:', err);
      error.value = err.message || '重置设置失败';
      throw err;
    }
  };

  /**
   * 导出设置为 JSON 字符串
   * 
   * @returns JSON 字符串
   */
  const exportPreferences = async (): Promise<string> => {
    try {
      console.log('[usePreferences] 导出设置...');

      const data = JSON.stringify(preferences.value, null, 2);

      console.log('[usePreferences] 设置导出成功');
      return data;
    } catch (err: any) {
      console.error('[usePreferences] 导出设置失败:', err);
      error.value = err.message || '导出设置失败';
      throw err;
    }
  };

  /**
   * 从 JSON 字符串导入设置
   * 
   * @param data - JSON 字符串
   */
  const importPreferences = async (data: string): Promise<void> => {
    try {
      console.log('[usePreferences] 导入设置...');

      const imported = JSON.parse(data) as UserPreferences;

      // 验证导入的数据
      const validated: UserPreferences = {
        ...defaultPreferences,
        ...imported,
      };

      preferences.value = validated;

      if (autoSave) {
        await savePreferences();
      }

      console.log('[usePreferences] 设置导入成功');
    } catch (err: any) {
      console.error('[usePreferences] 导入设置失败:', err);
      error.value = err.message || '导入设置失败';
      throw err;
    }
  };

  // 监听 facade 变化，自动加载设置
  watch(
    facade,
    async (newFacade) => {
      if (newFacade && autoLoad) {
        await loadPreferences();
      }
    },
    { immediate: true }
  );

  // 如果启用自动保存，监听偏好设置变化
  if (autoSave) {
    watch(
      preferences,
      async () => {
        if (facade.value) {
          try {
            await savePreferences();
          } catch (err) {
            // 自动保存失败不抛出错误，只记录日志
            console.warn('[usePreferences] 自动保存失败:', err);
          }
        }
      },
      { deep: true }
    );
  }

  return {
    preferences,
    isLoading,
    error,
    loadPreferences,
    savePreferences,
    updatePreference,
    updatePreferences,
    resetToDefaults,
    exportPreferences,
    importPreferences,
  };
}


